#include <stdio.h>
#include <stdlib.h>

// 平衡二叉树
// leadin 搜索树结点不同的插入次序会导致不同的深度和平均查找长度ASL,我们尝试通过设计让ASL最少

// 平衡因子 BF（T） = hl - hr
// 任意节点BF(L) 的绝对值<=1,就是一个平衡二叉树

// h满足O(log n)

// 平衡二叉树的调整
// RR旋转，LL旋转，LR旋转，RL旋转--->本质上就是看元素大小进行调整（先解决首要问题，后续问题自动解决）

// 小白专场： 对于输入的各种插入序列，判断他们是否可以生成相同的搜索二叉树
/*
输入：
4 2//每个序列4个整数，将有2个序列与标准序列进行比较
3 1 4 2//标准序列
3 4 1 2//比较序列
3 2 4 1//比较序列
2 1
2 1
1 2
0      //为0则退出程序
输出：
Yes
No
No
*/

/*
思路：
1.分别建两棵树的判别方法
2.不建树的判别方法
3.建一棵树，再判断序列是否一致

搜索树的表示？
怎么建树？
怎么判断序列是否一致？
*/

typedef struct TreeNode *BinTree;
struct TreeNode
{
    int data;
    BinTree left, right;
    int flag; // 用来标记该节点是否被访问过
};

BinTree CreateTree(int N);
int Judge(BinTree BT, int N);
void ResetFlag(BinTree BT);

int main()
{
    int N, L, i;
    BinTree BT;

    scanf("%d", &N); // 每一个序列N个数
    while (N)
    {
        scanf("%d", &L); // 将要比较L个序列
        BT = CreateTree(N);
        for (i = 0; i < L; i++)
        {
            if (Judge(BT, N))
                printf("Yes!\n");
            else
                printf("No!\n");
            ResetFlag(BT); // 这一步不要忘记！！归零BT中的所有flag，预备下一次的对比
        }
        FreeTree(BT);

        scanf("%d", &N); // 进入下一次比较，输入0则退出
    }
    return 0;
}

BinTree NewNode(int elem)
{
    BinTree T = (BinTree)malloc(sizeof(struct TreeNode));
    T->data = elem;
    T->left = T->right = NULL;
    T->flag = 0;
    return T;
}
BinTree Insert(BinTree T, int elem)
{
    if (T == NULL)
        T = NewNode(elem);
    if (elem < T->data)
        T->left = Insert(T->left, elem);
    else if (elem > T->data)
        T->right = Insert(T->right, elem);
    return T;
}
BinTree CreateTree(int N)
{
    BinTree T;
    int elem, i;

    scanf("%d", &elem);
    T = NewNode(elem);
    for (i = 1; i < N; i++)
    {
        scanf("%d", &elem);
        T = Insert(T, elem);
    }

    return T;
}

// 思路：在树BT中按输入顺序查找对应结点，若搜索过程中所经过的结点都在前面出现过，则这两棵树一样，否则不一样.
int check(BinTree BT, int elem)
{
    if (BT->flag)
    {
        if (elem < BT->data)
            return check(BT->left, elem);
        else if (elem > BT->data)
            return check(BT->right, elem);
        else
            return 0; // 相同的结点出现了两次，我们认为这两棵树不相同
    }
    else // 碰到了之前没有查找过的结点
    {
        if (elem == BT->data) // 若结点相同
        {
            BT->flag = 1;
            return 1;
        }
        else // 结点不同
            return 0;
    }
}
int Judge(BinTree BT, int N)
{
    int i, elem, flag = 0; // flag用来标记是否已经找到不合法的结点

    scanf("%d", &elem);
    if (elem != BT->data)
        flag = 1;
    else
        BT->flag = 1;
    for (i = 1; i < N; i++)
    {
        scanf("%d", &elem);              // 按顺序读取
        if (!flag && (!check(BT, elem))) // 如果已经找到了一个不相同的结点，flag已经为1，后面就不再需要调用check函数了
            flag = 1;
    }
    if (flag)
        return 0;
    else
        return 1;
}

// 重置flag，预备下一次的对比
void ResetFlag(BinTree BT)
{
    if (BT->left)
        ResetFlag(BT->left);
    if (BT->right)
        ResetFlag(BT->right);
    BT->flag = 0;
}
void FreeTree(BinTree BT)
{
    if (BT->left)
        FreeTree(BT->left);
    if (BT->right)
        FreeTree(BT->right);
    free(BT);
}